home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 398_01 / m08adr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-08-06  |  3.1 KB  |  216 lines
  1. /* m08adr.c */
  2.  
  3. /*
  4.  * (C) Copyright 1993
  5.  * All Rights Reserved
  6.  *
  7.  * Alan R. Baldwin
  8.  * 721 Berkeley St.
  9.  * Kent, Ohio  44240
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <setjmp.h>
  14. #include "asm.h"
  15. #include "m6808.h"
  16.  
  17. int
  18. addr(esp)
  19. register struct expr *esp;
  20. {
  21.     register c;
  22.     register struct area *espa;
  23.     register addr_t espv;
  24.     char *tcp;
  25.  
  26.     if ((c = getnb()) == '#') {
  27.         expr(esp, 0);
  28.         esp->e_mode = S_IMMED;
  29.     } else if (c == ',') {
  30.         switch(admode(axs)) {
  31.         default:
  32.             aerr();
  33.  
  34.         case S_X:
  35.             c = S_IX;
  36.             break;
  37.  
  38.         case S_S:
  39.             c = S_IS;
  40.             break;
  41.  
  42.         case S_XP:
  43.             c = S_IXP;
  44.             break;
  45.         }
  46.         esp->e_mode = c;
  47.         esp->e_flag = 0;
  48.         esp->e_addr = 0;
  49.         esp->e_base.e_ap = NULL;
  50.     } else if (c == '*') {
  51.         expr(esp, 0);
  52.         esp->e_mode = S_DIR;
  53.         if (esp->e_addr & ~0xFF)
  54.             err('d');
  55.         if (more()) {
  56.             comma();
  57.             tcp = ip;
  58.             switch(admode(axs)) {
  59.             case S_X:
  60.                 esp->e_mode = S_IX1;
  61.                 break;
  62.  
  63.             case S_S:
  64.                 esp->e_mode = S_SP1;
  65.                 break;
  66.  
  67.             case S_XP:
  68.                 esp->e_mode = S_IX1P;
  69.                 break;
  70.  
  71.             default:
  72.                 ip = --tcp;
  73.             }
  74.         }
  75.     } else {
  76.         unget(c);
  77.         if ((esp->e_mode = admode(axs)) != 0) {
  78.             ;
  79.         } else {
  80.             expr(esp, 0);
  81.             espa = esp->e_base.e_ap;
  82.             espv = esp->e_addr;
  83.             if (more()) {
  84.                 comma();
  85.                 c = admode(axs);
  86.                 if (esp->e_flag == 0 &&
  87.                     espa == NULL &&
  88.                     (espv & ~0xFF) == 0) {
  89.                     switch(c) {
  90.                     default:
  91.                         aerr();
  92.  
  93.                     case S_X:
  94.                         c = S_IX1;
  95.                         break;
  96.  
  97.                     case S_S:
  98.                         c = S_SP1;
  99.                         break;
  100.  
  101.                     case S_XP:
  102.                         c = S_IX1P;
  103.                         break;
  104.                     }
  105.                 } else {
  106.                     switch(c) {
  107.                     default:
  108.                         aerr();
  109.  
  110.                     case S_X:
  111.                         c = S_IX2;
  112.                         break;
  113.  
  114.                     case S_S:
  115.                         c = S_SP2;
  116.                         break;
  117.  
  118.                     case S_XP:
  119.                         c = S_IX2P;
  120.                         break;
  121.                     }
  122.                 }
  123.                 esp->e_mode = c;
  124.             } else {
  125.                 esp->e_mode = S_EXT;
  126.             }
  127.         }
  128.     }
  129.     return (esp->e_mode);
  130. }
  131.     
  132. /*
  133.  * Enter admode() to search a specific addressing mode table
  134.  * for a match. Return the addressing value on a match or
  135.  * zero for no match.
  136.  */
  137. int
  138. admode(sp)
  139. register struct adsym *sp;
  140. {
  141.     register char *ptr;
  142.     register int i;
  143.     unget(getnb());
  144.     i = 0;
  145.     while ( *(ptr = (char *) &sp[i]) ) {
  146.         if (srch(ptr)) {
  147.             return(sp[i].a_val);
  148.         }
  149.         i++;
  150.     }
  151.     return(0);
  152. }
  153.  
  154. /*
  155.  *      srch --- does string match ?
  156.  */
  157. int
  158. srch(str)
  159. register char *str;
  160. {
  161.     register char *ptr;
  162.     ptr = ip;
  163.  
  164. #if    CASE_SENSITIVE
  165.     while (*ptr && *str) {
  166.         if(*ptr != *str)
  167.             break;
  168.         ptr++;
  169.         str++;
  170.     }
  171.     if (*ptr == *str) {
  172.         ip = ptr;
  173.         return(1);
  174.     }
  175. #else
  176.     while (*ptr && *str) {
  177.         if(ccase[*ptr] != ccase[*str])
  178.             break;
  179.         ptr++;
  180.         str++;
  181.     }
  182.     if (ccase[*ptr] == ccase[*str]) {
  183.         ip = ptr;
  184.         return(1);
  185.     }
  186. #endif
  187.  
  188.     if (!*str)
  189.         if (any(*ptr," \t\n,];")) {
  190.             ip = ptr;
  191.             return(1);
  192.         }
  193.     return(0);
  194. }
  195.  
  196. /*
  197.  *      any --- does str contain c?
  198.  */
  199. int
  200. any(c,str)
  201. char    c, *str;
  202. {
  203.     while (*str)
  204.         if(*str++ == c)
  205.             return(1);
  206.     return(0);
  207. }
  208.  
  209. struct adsym    axs[] = {    /* a, x, or s registers */
  210.     "a",    S_A,
  211.     "x",    S_X,
  212.     "s",    S_S,
  213.     "x+",    S_XP,
  214.     "",    0x00
  215. };
  216.